#include"main.h"
int insert_into_file(char parent_Path[locationpath_size],char file_Name[filename_size],struct Block *blk,int size_of_file)//makedir
{
    struct FileDescriptor *fd1=NULL;
    FILE *fptr=NULL;
    int p,m;

    if(header.used_file_descriptors<header.MAX_FILE_DESCRIPTORS)
    {

        for(m=0; m<header.MAX_FILE_DESCRIPTORS; m++)
        {
            if(freelist[m]==0)
            {
                header.used_file_descriptors++;
                freelist[m]=1;
                fd1=&file_descriptors[m];
                //m=header.MAX_FILE_DESCRIPTORS;// to break out of loop in next iteration
                strcpy(fd1->filename,file_Name);
                strcpy(fd1->filetype,"file");// not updating location block number and file type*************************
                // updating the block number
                fd1->locationblocknumber=m;
                fd1->filesize=size_of_file;//strlen(blk->block);
                strcpy(fd1->locationfullpath,parent_Path);
                //  printf("block num1=%d",fd1->locationblocknumber);
                break;
                //printf("destination path=%s",fd1->locationfullpath);
            }
        }
    }
    else
    {
        //printf("fileoperations.c .. method name:insert_into_file  : no free file descriptors available");
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_04);
        //   fprintf(errfptr,"fileoperations.c : method name:insert_into_file status:exit1\n");
        return 0;// indiacting that no more fe file descriptors

    }
    //step2:for this free file descriptor we find the corrosponding free block number
    //step3:using this free block number we will write the block in the vfs file
    if((fptr=fopen(header.file_sys_label,"rb+"))==NULL)
    {
//        printf("\nI am printing from fileoperations.c .. method name:insert_into_file  : specified vfs file does not exist which can never happen");
        header.used_file_descriptors--;
        freelist[m]=0;
        // fprintf(errfptr,"fileoperations.c : method name:insert_into_file status:exit2\n");
        return 0;
    }
    else
    {
        //rewind(fptr);
        //printf("block num2=%d",m);
        fseek(fptr,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(m*sizeof(struct Block))),SEEK_SET);

        fwrite(blk,sizeof(struct Block),1,fptr);


        fclose(fptr);
    }

    //calling insert function of hash table
    insert_Into_HashTable(fd1);
    //calling insert function of N aray
    insert_nary(fd1);
    // calling inser function of bst
    insert_node(fd1);
    //m= search_nary(parent_Path);
    //if(m==1) printf("\nfileoperations.c:file found");
    //else printf("\nfileoperations.c:not found");
//fprintf(errfptr,"fileoperations.c : method name:insert_into_file status:exit3\n");
    return 1;

}
/*
#define ERR_VFS_ADDFILE_01 "UNABLE_TO_CREATE_NEWFILE"
#define ERR_VFS_ADDFILE_02 "INVALID_CHARACTER_IN_FILENAME"
#define ERR_VFS_ADDFILE_03 "FILE_ALREADY_EXISTS"
#define ERR_VFS_ADDFILE_04 "FILE_SYSTEM_FULL"
#define ERR_VFS_ADDFILE_05 "DESTINATION_PATH_MISSING"
#define ERR_VFS_ADDFILE_06 "DATAFILE_PATH_MISSING"
#define ERR_VFS_ADDFILE_07 "FILENAME_MISSING"
#define ERR_VFS_ADDFILE_08 "UNABLE_TO_OPEN_SPECIFIED_DATAFILE_PATH"
#define ERR_VFS_ADDFILE_09 "FILENAME_WITHOUT_EXTENSION"
#define ERR_VFS_ADDFILE_10 "FILE_SIZE_EXCEED_BLOCKSIZE"


#define ERR_VFS_ADDFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_ADDFILE_02 "INVALID_CHARACTER_IN_FILENAME"
#define ERR_VFS_ADDFILE_03 "FILE_ALREADY_EXISTS"
#define ERR_VFS_ADDFILE_04 "FILE_SYSTEM_FULL"
//New
#define ERR_VFS_ADDFILE_05 "CANNOT_WRITE_TO_DATAFILE"
//New : (if data exceeds block size)
#define ERR_VFS_ADDFILE_06 "FILE_TOO_LARGE"
//New
#define ERR_VFS_ADDFILE_07 "VFS_NOT_MOUNTED"
*/
//addfile_vfs25("/a/b/","vijay.txt","/home/vijayhuddar/Desktop/vijay.txt");
int addfile_vfs25(char dest_dir_path[locationpath_size],char file_name[filename_size],char data_file_path[locationpath_size])  //assumption is that ta file path has already
{
// appended with file name


    //opening the file specified in the path and putting the data in the created structure of block
    FILE *cfPtr=NULL;
    struct Block *blk= NULL;
    struct narytree *temp=NULL;
    int collect=0,i,size_of_file=0;
    char *cptr_dest_dir_path;

    //printf("vijay 1");
    //step 1-- check if file already exist
    //printf("%s",dest_dir_path);


    if( (errfptr=fopen("errorlog.txt","a")) == NULL )
    {
        fprintf(stderr,"Unable to open errorlog.txt i am in vfsdriver line 67");
        return(3);
    }
    fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:entered\n");


    if(strcmp(mountstate,"")==0)
    {
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_07);//vfs not mounted
        fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit1\n");
        fclose(errfptr);
        return 0;
    }

    //to check number of arguments
    if(strlen(file_name)==0 || strlen(dest_dir_path)==0 || strlen(data_file_path)==0)
    {
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_00);
        fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit2\n");
        fclose(errfptr);
        return 0;
    }
    // to check for invalid character in the file

    for(i=0; i<strlen(file_name); i++)
    {
        if(file_name[i]=='/')
        {
            printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_02);
            fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit3\n");
            fclose(errfptr);
            return 0;
        }

    }

    if(strcmp(dest_dir_path,"/")!=0)
    {
        if(dest_dir_path[strlen(dest_dir_path)-1]=='/')

            dest_dir_path[strlen(dest_dir_path)-1]='\0';
    }
    if (search_nary(dest_dir_path)==0)
    {
        //printf("fileoperations.c file already added cant add again\n");
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_05);//unable to create file because specified directory does not exist

        // printf("\naddfile_FAILURE:unable to create file because specified directory does not exist and corresponding error code does not exist");
        fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit4\n");
        fclose(errfptr);
        return 0;
    }
    else{
 //    if(dest_dir_path[strlen(dest_dir_path)-1]=='/')
   //         dest_dir_path[strlen(dest_dir_path)-1]='\0';

     if(strcmp(searched_Descriptor->filetype,"file")==0){
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_05);//unable to create file because specified directory does not exist
        // printf("\naddfile_FAILURE:unable to create file because specified directory does not exist and corresponding error code does not exist");
        fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit4\n");
        fclose(errfptr);
        return 0;
     }


    }

    if(strcmp(dest_dir_path,"/")!=0)
    {
        strcat(dest_dir_path,"/");
    }
    strcat(dest_dir_path,file_name);

    //step2: call the n aray search or bst search-- i am calling n aray search
    if (search_nary(dest_dir_path)==1)
    {
        //printf("fileoperations.c file already added cant add again\n");
        printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_03);
        fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit5\n");
        fclose(errfptr);
        return 0;
    }
    else
    {
        if ( ( cfPtr = fopen( data_file_path, "rb" ) ) == NULL )
        {
            printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_05);
            //printf("\naddfile_FAILURE:cannot open the specified source file because file not exist(no appropriate error code to map)");
            fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit6\n");
            fclose(errfptr);
            return 0;

        }
        else
        {
            fseek(cfPtr,0,SEEK_END);
            size_of_file=ftell(cfPtr);
            rewind(cfPtr);
            //printf("\nsize_of_file=%d",size_of_file);

            if(size_of_file<=blocksize)
            {
                blk= (struct Block *) malloc(sizeof(struct Block));
                //char blk[blocksize];
                //printf("vijay 2");
                // fread( blk->block,blocksize,1,cfPtr);      //blocksize,1,cfPtr);
                fread( blk->block,size_of_file,1,cfPtr);
                // printf("vijay 3 after reading from file");
                //strcat(blk->block,"\0");
                //printf("%s",blk->block);
                //call insert into file method
                fclose(cfPtr);
                collect= insert_into_file(dest_dir_path,file_name,blk,size_of_file);
                if(collect==1) printf("addfile_SUCCESS\n");
            }
            else
            {

                printf("addfile_FAILURE %s\n",ERR_VFS_ADDFILE_06);
                fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit7\n");
                fclose(errfptr);
                return 0;

            }

            //return collect;

        }


        //write the data into the file
        // but to erite i need the location of file descriptor
        // usg name i need file descriptor
    }
    // print_nary(nroot);
    fprintf(errfptr,"fileoperations.c : method name:addfile_vfs25 status:exit8\n");
    fclose(errfptr);
    return collect;

}



// code to search the file
/*
#define ERR_VFS_SEARCHFILE_01 "CANNOT_FIND_SPECIFIED_OUTPUTFILE"
#define ERR_VFS_SEARCHFILE_02 "OUTPUT_PATH_MISSING"

#define ERR_VFS_EXPORTFILE_04 "VFS_NOT_MOUNTED"

#define ERR_VFS_SEARCHFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
//New
#define ERR_VFS_SEARCHFILE_02 "VFS_NOT_MOUNTED"

*/
int searchfile_vfs25 ( char name_Of_File[filename_size], char output_Path_Of_File[locationpath_size] )
{

// call the hash table seaarch to know whether the file with the given name exist or no
    struct LinkedList * head=NULL;
    struct narytree *temp=NULL;
    FILE *fptr=NULL;
    char arr[50]="****************************";
    count_of_searchfile=0;

    if(strcmp(mountstate,"")==0)
    {
        printf("searchfile_FAILURE %s\n",ERR_VFS_SEARCHFILE_02);//vfs not mounted
//        fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:exit1\n");
        return 0;
    }
    //  fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:entered\n");



    if(strlen(output_Path_Of_File)==0 || strlen(name_Of_File)==0 )
    {
        printf("searchfile_FAILURE %s\n",ERR_VFS_SEARCHFILE_00);
        //    fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:exit2\n");
        return 0;
    }

    head=search_In_HashTable(name_Of_File);
    if(head!=NULL)
    {

        // printf("\nFiles found are:");
        if((fptr=fopen(output_Path_Of_File,"w"))==NULL)
        {
            // printf("\nsearchfile_FAILURE %s",ERR_VFS_SEARCHFILE_01);
            //      fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:exit3\n");
            return 0;
        }
        else
        {


            while(head!=NULL)
            {

                fprintf(fptr,"file name: %s\n",head->data->filename);
                fprintf(fptr,"filetype: %s\n",head->data->filetype);
                fprintf(fptr,"location full path: %s\n",head->data->locationfullpath);
                fprintf(fptr,"%s\n",arr);

                head=head->next;

            }

            fclose(fptr);
            printf("searchfile_SUCCESS %d\n",count_of_searchfile);
            //    fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:exit4\n");
            return 1;
        }
    }
    else
    {

//printf("hashtablesearch:file not found");
        printf("searchfile_SUCCESS %d\n",count_of_searchfile);
        //fprintf(errfptr,"fileoperations.c : method name:searchfile_vfs25 status:exit5\n");
        return 0;//

    }
}

/*#define ERR_VFS_UPDATEFILE_01 "SOURCE_FILE_PATH_NOT_FOUND"
#define ERR_VFS_UPDATEFILE_02 "DEST_FILE_PATH_NOT_FOUND"
#define ERR_VFS_UPDATEFILE_03 "INCORRECT_FILE_FORMAT"
#define ERR_VFS_UPDATEFILE_04 "FILE_SYSTEM_FULL"

*/
//time being we are not using this function
/*
int update_file(char path[locationpath_size],struct Block *blk,int length)
{
    struct FileDescriptor *fd1=NULL;
    FILE *fptr=NULL;
    int m,found=0,pos;
    for(m=0; m<header.MAX_FILE_DESCRIPTORS; m++)
    {
        fd1=&file_descriptors[m];
        if(freelist[m]==1 && strcmp(fd1->locationfullpath,path)==0 && strcmp(fd1->filetype,"file")==0)
        {
            found=1;
            // printf("found in updatefile m=%d",m);
            pos=m;
            break;
        }
    }

    if(found)
    {
        if((fptr=fopen(header.file_sys_label,"rb+"))==NULL)
        {
            //   printf("\nupdatefile:specified vfs file does not exist which can never happen");
            return 0;
        }
        else
        {
            fseek(fptr,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(pos*sizeof(struct Block))),SEEK_SET);
            fwrite(blk,length,1,fptr);
            fclose(fptr);
        }
    }

    return 1;

}

*/
/*

#define ERR_VFS_UPDATEFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_UPDATEFILE_01 "INTERNAL_FILE_NOT_FOUND"
#define ERR_VFS_UPDATEFILE_02 "EXTERNAL_FILE_NOT_FOUND"
//New
#define ERR_VFS_UPDATEFILE_03 "EXTERNAL_FILE_TOO_LARGE"
//New
#define ERR_VFS_UPDATEFILE_04 "VFS_NOT_MOUNTED"

*/
int updatefile_25(char file_path[locationpath_size], char data_path[locationpath_size])
{
    FILE *fptr=NULL;
    FILE *fp=NULL;
    struct Block *blk= NULL;
    int ret_val;
    struct SearchPath_BST* temp=NULL;
    char ext1[10],ext2[10];
    int i=0,j=0;
    int pos,m;
    if(strcmp(mountstate,"")==0)
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_04);//vfs not mounted
        return 0;
    }

    if(strlen(file_path)==0 ||strlen(data_path)==0)
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_00);
        return 0;
    }

    temp = search(bst_root,file_path);

    if (temp==NULL)
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_01);
        return 0;
    }

    if (access(data_path,F_OK) != 0)
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_02);
        return 0;
    }


    //  char ext1[10],ext2[10];
    //int i=0,j=0;

    fp=fopen(data_path,"r");
    if(fp==NULL)
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_02);
        return 0;

    }
    fseek(fp,0,SEEK_END);
    int length=ftell(fp);
    if(length<0 || length>blocksize)//allowing to update file when length is 0
    {
        printf("updatefile_FAILURE %s\n",ERR_VFS_UPDATEFILE_03);
        return 0;
    }

    //int l = temp->data->filesiz
    temp->data->filesize=length;
    fseek(fp,0,SEEK_SET);
    blk= (struct Block *) malloc(sizeof(struct Block));
    fread(blk->block,length,1,fp);
    fclose(fp);
    //ret_val = update_file(file_path,blk,length);
    pos=temp->data->locationblocknumber;
    if((fptr=fopen(header.file_sys_label,"rb+"))==NULL)
    {
        printf("updatefile:specified vfs file does not exist which can never happen\n");
        return 0;
    }
    else
    {
        fseek(fptr,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(pos*sizeof(struct Block))),SEEK_SET);
        fwrite(blk,sizeof(struct Block),1,fptr);
        fclose(fptr);
    }

    //if(ret_val)
    printf("updatefile_SUCCESS\n");
    return ret_val;
}


/*#define ERR_VFS_LISTFILE_01 "SOURCE_FILE_PATH_NOT_FOUND"
#define ERR_VFS_LISTFILE_02 "OUTPUT_FILE_PATH_NOT_FOUND"
#define ERR_VFS_LISTFILE_03 "SOURCE_PATH_MISSING"
#define ERR_VFS_LISTFILE_04 "OUTPUT_PATH_MISSING"
#define ERR_VFS_LISTFILE_05 "NOT_A_TEXT_FILE"*/

/*
/#define ERR_VFS_LISTFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_LISTFILE_01 "SOURCE_FILE_PATH_NOT_FOUND"
#define ERR_VFS_LISTFILE_02 "NOT_A_TEXT_FILE"
#define ERR_VFS_LISTFILE_03 "CANNOT_CREATE_OUTPUTFILE"
#define ERR_VFS_LISTFILE_04 "VFS_NOT_MOUNTED"
#define ERR_VFS_LISTFILE_05 "OUTPUT_FILE_PATH_NOT_FOUND"


#define ERR_VFS_LISTFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_LISTFILE_01 "SOURCE_FILE_PATH_NOT_FOUND"
#define ERR_VFS_LISTFILE_02 "NOT_A_TEXT_FILE"
#define ERR_VFS_LISTFILE_03 "CANNOT_CREATE_OUTPUTFILE"
#define ERR_VFS_LISTFILE_04 "VFS_NOT_MOUNTED"

*/
int listfile_25(char file_path[locationpath_size],char out_path[locationpath_size])
{
    struct SearchPath_BST *temp=NULL;
    int bno= 0;
    int size_of_file=0;
    FILE *fp=NULL;
    struct Block *blk=NULL;



    if(strcmp(mountstate,"")==0)
    {
        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_04);//vfs not mounted
        return 0;
    }


    if((strlen(file_path)==0)||(strlen(out_path)==0))
    {
        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_00);
        return 0;
    }

    /* if(access(out_path,F_OK)!=0)
    {
        printf("\nlistfile_FAILURE %s",ERR_VFS_LISTFILE_03);
        return 0;
    }*/

    if(search_nary(file_path)==0)
    {
        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_01);
        return 0;
    }




    if(strlen(file_path) >4 )
    {
        if(file_path[strlen(file_path)-1]!='t' || file_path[strlen(file_path)-2]!='x' || file_path[strlen(file_path)-3]!='t' || file_path[strlen(file_path)-4]!='.')
        {
            printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_02);
            return 0;
        }
    }
    else
    {
        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_02);
        return 0;

    }

    //clarify before removing comment if you remove comment then destination file not ending with .txt are not allowed
     if(strlen(out_path) >4 )
      {
          if(out_path[strlen(out_path)-1]!='t' || out_path[strlen(out_path)-2]!='x' || out_path[strlen(out_path)-3]!='t' || out_path[strlen(out_path)-4]!='.')
          {
              printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_03);
              return 0;
          }
      }
      else
      {
          printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_03);
          return 0;

      }


    if(strcmp(file_path,"/")==0)
    {

        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_02);
        return 0;
    }


    temp=search(bst_root, file_path);
    bno= temp->data->locationblocknumber;
    size_of_file=temp->data->filesize;

    //fp=NULL;
    blk= (struct Block *)malloc(sizeof(struct Block));
    //char somthng[blocksize];

    fp=fopen(header.file_sys_label,"rb");
    if(fp==NULL)
    {
        printf("cannot open vfs file\n");
        return 0;
    }
    fseek(fp,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(bno*sizeof(struct Block))),SEEK_SET);
    //fread(blk->block,size_of_file,1,fp);//sizeof(struct Block),1,fp);
    fread(blk,sizeof(struct Block),1,fp);

    fclose(fp);
    fp=NULL;

    // printf("printing");

    //  printf("%d",strlen(somthng));
    fp=fopen(out_path,"w");
    if(fp==NULL)
    {
        printf("listfile_FAILURE %s\n",ERR_VFS_LISTFILE_03);
    }
    fwrite(blk->block,size_of_file,1,fp);//strlen(blk.block),1,fp);
    fclose(fp);
    printf("listfile_SUCCESS\n");
    return 1;
}


//movefile P1 P2
//P1 – source_file_with_path
//P2 – destination path
/*
#define ERR_VFS_MOVEFILE_01 "CANNOT_FIND_SPECIFIED_SOURCEFILE"
#define ERR_VFS_MOVEFILE_02 "CANNOT_FIND_SPECIFIED_DESTINATIONFILE"
#define ERR_VFS_MOVEFILE_03 "SOURCE_PATH_MISSING"
#define ERR_VFS_MOVEFILE_04 "DESTINATION_PATH_MISSING"
#define ERR_VFS_MOVEFILE_05 "FILE_ALREADY_EXISTS"// missing in sir



#define ERR_VFS_MOVEFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_MOVEFILE_01 "CANNOT_FIND_SOURCEFILE"
#define ERR_VFS_MOVEFILE_02 "CANNOT_FIND_DESTINATION_PATH"
//New
#define ERR_VFS_MOVEFILE_06 "VFS_NOT_MOUNTED"
*/
//movefile /a/b/file2.txt /a/file2_new.txt
int movefile_vfs25( char source_file_with_path[locationpath_size], char destination_file_path[locationpath_size] ) // need to check whether we are moving the file or directory
{

    int state,i,state1;
    struct SearchPath_BST *temp;
    struct SearchPath_BST *temp1;
    struct FileDescriptor *store_FD=NULL;
    char delim[]="/",save_locationpath[locationpath_size],save_Destinationpath[locationpath_size],destpath_saved[locationpath_size];
    char *result=NULL,*prev_result=NULL;
    char filename[filename_size];
    char filename_destination[filename_size];
    int returnval=0;
    //code to check whether the filesystem is mounted or not

    if( (errfptr=fopen("errorlog.txt","a")) == NULL )
    {
        fprintf(stderr,"Unable to open errorlog.txt i am in vfsdriver line 67");
        return(3);
    }
    fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:entered\n");

    if(strcmp(mountstate,"")==0)
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_06);//vfs not mounted
        fclose(errfptr);
        return 0;
    }

//arguments checking
// to check whether two arguments are passed or not

    if(strlen(source_file_with_path)==0 || strlen(destination_file_path)==0)
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_00);
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 0;
    }


    if(strcmp(destination_file_path,"/")==0)
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_02);
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 0;
    }

    if(strcmp(source_file_with_path,"/")==0)
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_01);
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 0;
    }

//to check whether specified destination file exist or not and if exist is it the directory or file
    // strcpy(save_Destinationpath,destination_file_path);

    //check for source availability
    strcpy(save_locationpath,source_file_with_path);
    state=search_nary(save_locationpath);

    temp=search(bst_root,save_locationpath);

    if(searched_Descriptor==NULL && state==0)
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_01);
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 0;
    }

    if(searched_Descriptor!=NULL)
    {
        if(strcmp(searched_Descriptor->filetype,"dir")==0) // to check whether the found destination is dirctory or not
        {
            printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_01);
            fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
            fclose(errfptr);
            return 0;
        }
    }

    strcpy(save_Destinationpath,destination_file_path);
    temp1=search(bst_root,save_Destinationpath);
    state1=search_nary(save_Destinationpath);

    if(temp1==NULL)
    {

        for(i=(strlen(save_Destinationpath)-1); i>=0; i--)
        {

            if(save_Destinationpath[i] != '/')
            {

                save_Destinationpath[i]='\0';

            }
            else
            {
                save_Destinationpath[i]='\0';
                break;
            }

        }

        state1=search_nary(save_Destinationpath);

        if(searched_Descriptor==NULL)
        {
            printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_02);
            fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
            fclose(errfptr);
            return 0;
        }
        if(searched_Descriptor!=NULL)
        {

            if(strcmp(searched_Descriptor->filetype,"file")==0) // to check whether the found destination is dirctory or not
            {
                printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_02);
                fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
                fclose(errfptr);
                return 0;
            }

        }

    }

    else  if((temp1!=NULL) && (state1!=0 )&& (strcmp(temp1->data->filetype,"dir")==0)) //destination is not a file
    {
        printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_02);
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 0;
    }

    if(strcmp(source_file_with_path,destination_file_path)==0)
    {
        printf("movefile_SUCCESS\n");
        fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
        fclose(errfptr);
        return 1;

    }
    if(temp1!=NULL && state1!=0) // destination is a file then delete it call delete file
    {
//removefile_vfs25(char* filepath)
        //printf("remove file destination filepath\n");
        returnval=removefile_vfs25_movefile(destination_file_path);
        if(returnval==0)
        {
            printf("movefile_FAILURE %s\n",ERR_VFS_MOVEFILE_02);
            fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
            fclose(errfptr);
            return 0;
        }
    }


    //printf("source_path:value of temp=%ld \nvalue of state=%d",temp,state);
    store_FD=temp->data;
    //call the delete of hash table
    delete_From_HashTable(store_FD->locationfullpath);
    //call delete of BST
    delete_node(bst_root,store_FD->locationfullpath);
    // call the delete of nary
    state=delete_file_from_nary(store_FD->locationfullpath);
    //code to extract the file name of destination
    result=NULL;
    prev_result=NULL;
    strcpy(save_Destinationpath,destination_file_path);
    //printf("")
    result=strtok(save_Destinationpath,delim);

    while (result!=NULL)
    {
        // printf("%s\t",result);
        prev_result=result;
        result=strtok(NULL,delim);
    }

    strcpy(filename_destination,prev_result);
    strcpy(store_FD->filename,filename_destination);
    strcpy(store_FD->locationfullpath,destination_file_path);

    insert_nary(store_FD);
    insert_node(store_FD);
    insert_Into_HashTable(store_FD);
    // printf("\n   display dir from move file");

    printf("movefile_SUCCESS\n");
    fprintf(errfptr,"fileoperations.c : command name: movefile_vfs25 ststus:exit\n");
    fclose(errfptr);
    return 1;


}


int removefile_vfs25_movefile(char filepath[locationpath_size])
{
    int i,count;
    struct SearchPath_BST *temp=NULL;
//    fprintf(errfptr,"fileoperations.c : method name:removefile_vfs25_movefle status:entered\n");
    if (search_nary(filepath)==0)
    {
        // printf("\nremovefile_FAILURE %s",ERR_VFS_REMOVEFILE_01);
        //      fprintf(errfptr,"fileoperations.c : method name:removefile_vfs25_movefle status:exit1\n");
        return 0;
    }
    temp=search(bst_root,filepath);
    if(temp!= NULL)
    {

        if(strcmp(temp->data->filetype,"file") !=0)
        {
            //     printf("\nremovefile_FAILURE %s",ERR_VFS_REMOVEFILE_02);
            //        fprintf(errfptr,"fileoperations.c : method name:removefile_vfs25_movefle status:exit2\n");
            return 0;
        }

        delete_file_from_nary(filepath);
        delete_From_HashTable(filepath);
        //struct SearchPath_BST *temp;
        temp=search(bst_root, filepath);
        int bno= temp->data->locationblocknumber;
        delete_node(bst_root, filepath);
        header.used_file_descriptors--;

        freelist[bno]=0;
        // printf("\nremovefile_SUCCESS");
        //print_nary(nroot);
        //fprintf(errfptr,"fileoperations.c : method name:removefile_vfs25_movefle status:exit3\n");
        return 1;
    }
    //fprintf(errfptr,"fileoperations.c : method name:removefile_vfs25_movefle status:exit4\n");
    return 0;

}
/*
#define ERR_VFS_REMOVEFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
// Use this error even when the given argument is a directory and not a file
#define ERR_VFS_REMOVEFILE_01 "CANNOT_FIND_SPECIFIED_FILE"
//New
#define ERR_VFS_REMOVEFILE_02 "VFS_NOT_MOUNTED"

*/
int removefile_vfs25(char filepath[locationpath_size])
{
    int i,count,bno;
    struct SearchPath_BST *temp=NULL;
    if(strcmp(mountstate,"")==0)
    {
        printf("removefile_FAILURE %s\n",ERR_VFS_REMOVEFILE_02);
        return 0;
    }

    if(strlen(filepath)==0)
    {
        printf("removefile_FAILURE %s\n",ERR_VFS_REMOVEFILE_00);
        return 0;
    }

 //   printf("search nary result=%d",search_nary(filepath));

    if (search_nary(filepath)==0)
    {
        printf("removefile_FAILURE %s\n",ERR_VFS_REMOVEFILE_01);
        return 0;
    }
//redundant but let it be
    if(searched_Descriptor==NULL)
    {
        printf("removefile_FAILURE %s\n",ERR_VFS_REMOVEFILE_01);
        return 0;

    }

    if(searched_Descriptor!=NULL && (strcmp(searched_Descriptor->filetype,"dir")==0 || strcmp(searched_Descriptor->filetype,"root")==0))
    {

        printf("removefile_FAILURE %s\n",ERR_VFS_REMOVEFILE_01);
        return 0;

    }



    delete_file_from_nary(filepath);
    delete_From_HashTable(filepath);
    //temp=search(bst_root, filepath);

    bno= searched_Descriptor->locationblocknumber;


    delete_node(bst_root, filepath);

    header.used_file_descriptors--;

    freelist[bno]=0;
    printf("removefile_SUCCESS\n");
    //print_nary(nroot);
    return 1;

}


/*
#define ERR_VFS_COPYFILE_01 "CANNOT_FIND_SPECIFIED_SOURCEFILE"
#define ERR_VFS_COPYFILE_02 "CANNOT_FIND_SPECIFIED_DESTINATIONFILE"
#define ERR_VFS_COPYFILE_03 "SOURCE_PATH_MISSING"
#define ERR_VFS_COPYFILE_04 "DESTINATION_PATH_MISSING"
#define ERR_VFS_COPYFILE_05 "CANNOT_COPY_DIR_TO_FILE"
#define ERR_VFS_COPYFILE_06 "FILE_SYSTEM_FULL"

#define ERR_VFS_COPYFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_COPYFILE_01 "CANNOT_FIND_SOURCEFILE"
#define ERR_VFS_COPYFILE_02 "CANNOT_FIND_DESTINATIONPATH"
#define ERR_VFS_COPYFILE_03 "CANNOT_COPY_DIR_TO_FILE"
#define ERR_VFS_COPYFILE_04 "FILE_SYSTEM_FULL"
#define ERR_VFS_COPYFILE_05 "VFS_NOT_MOUNTED"
copyfile /a/b/file1.txt /m/n/o/file1.txt
*/
int copyfile_vfs25(char sourceFilePath[locationpath_size], char destPath[locationpath_size])
{
    FILE *fp=NULL;
    int flag1=0,status,s=0,m=0,i,d=0,state1=0,state2=0,flag=0;
    char destpath_saved[locationpath_size];
    char save_locationpath[locationpath_size];
    struct SearchPath_BST* node= NULL;//search(bst_root,sourceFilePath);
    struct SearchPath_BST* temp= NULL;//search(bst_root,destPath);
    struct FileDescriptor *fd1=NULL;
    struct FileDescriptor *searched_Descriptor1=NULL;
    struct FileDescriptor *searched_Descriptor2=NULL;
        struct FileDescriptor *searched_Descriptor3=NULL;
    char delim[]="/";
    char *result=NULL,*prev_result=NULL;
    char filename[filename_size];

    if( (errfptr=fopen("errorlog.txt","a")) == NULL )
    {
        fprintf(stderr,"Unable to open errorlog.txt i am in vfsdriver line 67");
        return(3);
    }


    fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:entered\n");

    if(strcmp(mountstate,"")==0)
    {
        printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_05);
        fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
        fclose(errfptr);
        return 0;
    }
    //method to extract destination file name
//code to check whether file system is mounted or no
//code to check missing arguments
    if(strlen(sourceFilePath)==0 || strlen(destPath)==0)
    {
        printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_00);
        fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
        fclose(errfptr);
        return 0;
    }
    strcpy(save_locationpath,sourceFilePath);
    strcpy(destpath_saved,destPath);

    state1=search_nary(save_locationpath);
    searched_Descriptor1=searched_Descriptor;

    state2=search_nary(destpath_saved);
    searched_Descriptor2=searched_Descriptor;

//node=search(bst_root,sourceFilePath);
//node_destination=search(bst_root,destPath);

//sourcepath is not found

    if(searched_Descriptor1==NULL)
    {

        printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_01);
        fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
        fclose(errfptr);
        return 0;

    }
    else if (strcmp(searched_Descriptor1->filetype,"dir")==0 || strcmp(searched_Descriptor1->filetype,"root")==0)
    {

        if(searched_Descriptor2==NULL || strcmp(searched_Descriptor2->filetype,"dir")==0)
        {

            printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_01);
            fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
            fclose(errfptr);
            return 0;

        }
        else if(strcmp(searched_Descriptor2->filetype,"file")==0)
        {
            printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_03);
            fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
            fclose(errfptr);
            return 0;
        }
    }


    if(searched_Descriptor2!=NULL)
    {

        if(strcmp(searched_Descriptor2->filetype,"dir")==0 || strcmp(searched_Descriptor2->filetype,"root")==0)
        {
            printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_02);
            fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit1\n");
            fclose(errfptr);
            return 0;
        }

        flag=1;
    }
    else //destination path is not found
    {

//if(strcmp(des))

        //to check destination
        //to check destination filepath
        strcpy(destpath_saved,destPath);
        //  if(strcmp(destpath_saved,"/") !=0)
        //{
        for(i=(strlen(destpath_saved)-1); i>=0; i--)
        {
            if(destpath_saved[i] != '/')
            {

                destpath_saved[i]='\0';

            }
            else
            {
                if(strcmp(destpath_saved,"/")==0){//vijay added recently
                flag1=1;
                }
                destpath_saved[i]='\0';
                break;
            }

        }

        //printf("  destpath_saved =%s  ",destpath_saved);

  if(flag1!=1){

        temp=search(bst_root,destpath_saved);

        if(temp==NULL || strcmp(destpath_saved,"/")==0 )
        {

            printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_02);// need to change the error code message saying that dest dir not found
            fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit4\n");
            fclose(errfptr);
            return 0;
        }
    }
    else{

    strcpy(destpath_saved,"/");
    }

    }

    strcpy(destpath_saved,destPath);
    result=strtok(destpath_saved,delim);

    while (result!=NULL)
    {
        // printf("%s\t",result);
        prev_result=result;
        result=strtok(NULL,delim);
    }
    strcpy(filename,prev_result);


    if(flag==0) //flag==0 indicate destination is not existing
    {




//strcpy(destpath_saved,destPath);
        // temp=search(bst_root,destPath);

        //if(temp ==NULL)
        // {
        if(header.used_file_descriptors<header.MAX_FILE_DESCRIPTORS)
        {

            for(m=0; m<header.MAX_FILE_DESCRIPTORS; m++)
            {
                if(freelist[m]==0)
                {
                    header.used_file_descriptors++;
                    freelist[m]=1;
                    fd1=&file_descriptors[m];
                    strcpy(fd1->filename,filename);
                    strcpy(fd1->locationfullpath,destPath);
                    strcpy(fd1->filetype,searched_Descriptor1->filetype);
                    fd1->filesize=searched_Descriptor1->filesize;
                    fd1->locationblocknumber=m;
                    break;
                    //printf("destination path=%s",fd1->locationfullpath);
                }
            }
        }
        else
        {
            printf("copyfile_FAILURE %s\n",ERR_VFS_COPYFILE_04);// need to change the error code message saying that dest dir not found
            fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit5\n");
            fclose(errfptr);
            return 0;
        }
        status=insert_nary(fd1);
        if(status)
        {
            //  printf("successfully copied to n-ary");
            insert_node(fd1);//calling bst insertion
            insert_Into_HashTable(fd1);// calling hash table insertion
        }


        // i feel this code should should come here
    }
    else if(flag!=0)
    {
        fd1=searched_Descriptor1;
        //  strcpy(fd1->filename,filename);
        // strcpy(fd1->locationfullpath,destPath);
        strcpy(fd1->filetype,searched_Descriptor1->filetype);
        fd1->filesize=searched_Descriptor1->filesize;
    }





    s=fd1->filesize;//node->data->locationblocknumber;
    d=fd1->locationblocknumber;
    m=searched_Descriptor1->locationblocknumber;
    insert_into_block_copyfile(s,m,d);
    printf("copyfile_SUCCESS\n");
    fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit6\n");
    fclose(errfptr);
    return 1;
    //  }

    /*
      else // if the file specified in destination already exist
      {

          if (strcmp(temp->data->filetype,"dir")==0)
          {
              //printf("\ncopyfile_FAILURE :cannot copy file to directory i.e it is a directory path not file");//"%s,ERR_VFS_COPYFILE_07);// need to change the error code message saying that dest dir not found
              printf("\ncopyfile_FAILURE :%s",ERR_VFS_COPYFILE_02);
              fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit7\n");
              fclose(errfptr);
              return 0;
          }
          fd1=temp->data;
          strcpy(fd1->filetype,node->data->filetype);
          fd1->filesize=node->data->filesize;
          //fd1,node,node->locationblocknumber
          s=node->data->filesize;//location from hwere you want to read the data
          m=node->data->locationblocknumber;
          d=fd1->locationblocknumber;
          insert_into_block_copyfile(s,m,d);
          printf("\ncopyfile_SUCCESS");
          fprintf(errfptr,"fileoperations.c : method name:copyfile_vfs25 status:exit8\n");
          fclose(errfptr);
          return 1;

      }*/
}
/*
s=fd1->filesize;//node->data->locationblocknumber;
d=fd1->locationblocknumber;
m=searched_Descriptor1->mydes->locationblocknumber;
*/
int insert_into_block_copyfile(int s,int m,int d)//s=size and m=location block number
{
//int m=0;
    FILE *fp=NULL;
    struct Block* b=NULL;
    //fprintf(errfptr,"fileoperations.c : method name:insert_into_block_copyfile status:entered\n");
    //open file seek to that block using node->data->locationblocknumber read it and write to location using fd1->locationblocknumber
    if((fp=fopen(header.file_sys_label,"rb+"))==NULL)
    {
        printf("File could not be opened\n");
        //  fprintf(errfptr,"fileoperations.c : method name:insert_into_block_copyfile status:exit1\n");
        return 0;
    }
    //m=node->data->locationblocknumber;
    fseek(fp,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(m*sizeof(struct Block))),SEEK_SET);
    /*----create a block to read the data to and read the data from vfs_path ----*/
    // printf("12 bhavani\n");
    b=(struct Block*) malloc (sizeof(struct Block));
    // printf("13 bhavani\n");
    fread(b,s,1,fp);//sizeof(struct Block),1,fp);
    fseek(fp,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(d*sizeof(struct Block))),SEEK_SET);
    fwrite(b,s,1,fp);//sizeof(struct Block),1,fp);
    //strcat(blk->block,"\0");
    //  printf("14 bhavani\n   data=%s",b->block);
    // printf("\ndatain block:%s",b->block);
    fclose(fp);
    //fprintf(errfptr,"fileoperations.c : method name:insert_into_block_copyfile status:exit2\n");
    return 1;
}


/*

#define ERR_VFS_EXPORTFILE_00 "VFS_INSUFFICIENT_ARGUMENTS"
#define ERR_VFS_EXPORTFILE_01 "CANNOT_FIND_SOURCEFILE"
#define ERR_VFS_EXPORTFILE_02 "CANNOT_CREATE_OUTPUTFILE"
#define ERR_VFS_EXPORTFILE_03 "CANNOT_EXPORT_DIR"
//New
#define ERR_VFS_EXPORTFILE_04 "VFS_NOT_MOUNTED"
*/

int exportFile_vfs25(char vfs_path[locationpath_size], char disk_path[locationpath_size])
{

    FILE *fp=NULL, *fp_disk=NULL;
    char filename[filename_size];
    char data[blocksize];
    struct SearchPath_BST *node=NULL;
    struct Block *b=NULL;
    int m,ret_val=0;
    int found=0,pos;
    struct FileDescriptor *fd1=NULL;


    if(strcmp(mountstate,"")==0)
    {
        printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_04);
        return 0;
    }
    //printf("node%s",node->data->filename);


    /*----search for a node with the locationfullpath as vfs_path----*/

    //search_nary(vfs_path);


    if(strlen(vfs_path)==0 || strlen(disk_path)==0)
    {
        printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_00);
        return 0;
    }
    node = search(bst_root,vfs_path);

    if(strcmp(vfs_path,"/")==0){

      printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_03);
      return 0;
    }
    if(node==NULL)
    {
        printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_01);
        return 0;
    }


    /*----If it exists, open vfs_path in read mode----*/
    if(strcmp(node->data->filetype,"dir")==0)
    {
        printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_03);
        return 0;
    }


    if((fp=fopen(header.file_sys_label,"rb"))==NULL)
    {
        printf("File could not be opened\n");
        return 0;
    }

        pos=node->data->locationblocknumber;


        fseek(fp,(sizeof(struct MainHeader)+(header.MAX_FILE_DESCRIPTORS*sizeof(char))+(header.MAX_FILE_DESCRIPTORS*sizeof(struct FileDescriptor))+(pos*sizeof(struct Block))),SEEK_SET);
        /*----create a block to read the data to and read the data from vfs_path ----*/

        b=(struct Block*) malloc (sizeof(struct Block));

        //fread(b->block,blocksize,1,fp);
        fread(b,sizeof( struct Block),1,fp);
        fclose(fp);
        /*----If the0 disk_path is a valid path----*/
        //if(access(disk_path, F_OK)==0)
        //{

            strcpy(filename,node->data->filename);
            /*---disk_path is a valid directory and it is now appended with the filename (which has to be exported) and has to be opened in write mode---*/
          //  if(disk_path[strlen(disk_path)-1]!='/')
            //    strcat(disk_path,"/");
            //strcat(disk_path,filename);

            fp_disk = fopen(disk_path,"wb+");

            if(fp_disk==NULL){

            printf("exportfile_FAILURE %s\n",ERR_VFS_EXPORTFILE_02);
            return 0;

            }

            else
            {
                //strcpy(data,b->block);
                fwrite(b->block,node->data->filesize,1,fp_disk);
                //fseek(fp_disk,strlen(b->block),SEEK_SET);
                //fputc(EOF,fp_disk);
                fclose(fp_disk);
               // ret_val=1;
            }

       // }
       // else
        //{
          //  printf("\nexportfile_FAILURE %s",ERR_VFS_EXPORTFILE_02);
            //return 0;
        //}
   // }


  //  if(ret_val)
        printf("exportfile_SUCCESS\n");
    return 1;
}



